import Cookies from 'js-cookie'
import router from '@/router/index'

interface obj {
  [key:string]:any
}
const func = {
    /** 存储数据到cookie中
     * @params {string} key 
     * @params {string|number} value 
     * @params {number} expires default one day 过期时间
     */
    setCookie: (key:string, value:string|number, expires = 1) => {
        Cookies.set(key, value.toString(), { expires })
    },
    /** 获取cookie中的值
     * @params {string} key 
     * @return {string} value
     */
    getCookie: (key:string):string|undefined => Cookies.get(key),
    /** 移除cookie中指定的数据项
     * @params {string} key 
     */
    removeCookie: (key:string) => {
        Cookies.remove(key)
    },
    /**
     * routerpush方法改写
     * @params {string} id
     */
    routerPush(id:string) {
        const { options: { routes } } = router
        const flatten = (routes:any[], arr?:any[]) => {
            const res = arr || []
            routes.forEach(route => {
                res.push(route)
                if (route.children) {
                    return flatten(route.children, res)
                }
            })
            return res
        }
        const routeData :any[] = flatten(routes)
        const cur = routeData.find(route => route?.meta?.appId == id)
        if (cur) {
            router.push({
                name: cur.name,
            })
        } else {
            router.push({
                name: '404',
            })
        }
    }, 
    
    /**
   * 对象扁平化
   * @params {object} 要扁平化的对象
   * @return {object} 扁平化后的对象
   */
    flat(obj:obj) {
        const flatten = (res:obj, curObj:any, curKey:string) => {
            // 判断当前项是否为数组
            if (Array.isArray(curObj)) {
                curObj.forEach((item, idx) => {
                    // 如果是复杂对象则继续
                    if (typeof item == 'object' && item !== null) {
                        flatten(res, item, `${curKey}[${idx}]`)
                    } else {
                        res[`${curKey}[${idx}]`] = item
                    }
                })
            } else {
                Object.keys(curObj).forEach(key => {
                    // 复杂对象嵌套则继续
                    if (typeof curObj[key] === 'object' && curObj[key] !== null) {
                        flatten(res, curObj[key], `${curKey}.${key}`)
                    } else {
                        res[`${curKey}.${key}`] = curObj[key]
                    }
                })
            }
        }
        const res:obj = {}
        Object.keys(obj).forEach(key => {
            if (typeof obj[key] === 'object' && obj[key] !== null) {
                flatten(res, obj[key], key)
            } else {
                res[key] = obj[key]
            }
        })
        return res
    },
    /**
     * 对象反扁平化
     * @params {object} 扁平化的对象
     * @return {object} 反扁平化的对象
     */
    unflat(obj:obj) {
        const unflatten = (key:string, value:any, res:obj) => {
            const arr = key.split('.')
            let tmp = res
            for (let i = 0; i < arr.length; i++) {
                let key = arr[i]
                let nextKey = arr[i + 1]
                // 这里需要判断key 是否包含[]字符串，如果是则是数组结构
                if (/\[.+?\]/g.test(key)) {
                    // 可能是多维数组，匹配数组维度
                    let indexs = key.match(/\[(.+?)\]/g)!
                    // 获取数组的key值
                    let _key = key.match(/^(.+?)\[/)[1]
                    // 构造数组需要判断是否已经存在
                    tmp[_key] = tmp[_key] ? tmp[_key] : []
                    let n = tmp[_key]
              
                    // 构造完数组对数组里面进行构造
                    for (let j = 0; j < indexs.length; j++) {
                        let index = indexs[j].replace(/\[|\]/g, '')
                        let nextIndex = indexs[j + 1]
               
                        // 数组包含数组
                        if (nextIndex) {
                            // 构造数组需要判断是否已经存在
                
                            n[index] = n[index] ? n[index] : []
                            // 如果还包含数组，将n指针指向下一个数组
                            n = n[index]
                            // 如果后面还有则构造对象
                        } else if (nextKey) {
                            // 构造对象需要判断是否已经存在
                            n[index] = n[index] ? n[index] : {}
                            tmp = n[index]
                        } else {
                            n[index] = value
                        }
                    }
                    // 不是数组和之前方法保持一致
                } else if (nextKey) {
                    // 构造对象需要判断是否已经存在
                    tmp[key] = tmp[key] ? tmp[key] : {}
                    tmp = tmp[key]
                } else {
                    tmp[key] = value
                }
            }
        }
        const res:obj = {}
        Object.keys(obj).forEach(key => {
            unflatten(key, obj[key], res)
        })
        return res
    },
}

export default func
